home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / TOOLTIP.PAK / TOOLTIPX.CPP < prev   
C/C++ Source or Header  |  1997-05-06  |  8KB  |  284 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (c) 1995, 1996 by Borland International, All Rights Reserved
  4. //
  5. // Illustrates usage of TTooltip class
  6. //----------------------------------------------------------------------------
  7. #include <owl/pch.h>
  8. #include <owl/decframe.h>
  9. #include <owl/statusba.h>
  10. #include <owl/controlb.h>
  11. #include <owl/buttonga.h>
  12. #include <owl/inputdia.h>
  13. #include <owl/tooltip.h>
  14. #include <owl/combobox.h>
  15. #include <owl/controlg.h>
  16. #include <stdio.h>
  17. #include "tooltip.h"
  18.  
  19. const int ID_COMBOBOX = 0x1000;
  20.  
  21. TRect redRect   = TRect(10, 10, 100, 100);
  22. TRect blueRect  = TRect(110, 10, 200, 100);
  23. TRect yellowRect= TRect(10, 110, 100, 200);
  24. TRect greenRect = TRect(110, 110, 200, 200);
  25.  
  26. //
  27. // class TSampleApp
  28. // ~~~~~ ~~~~~~~~~~
  29. class TSampleApp : public TApplication {
  30.   public:
  31.     TSampleApp() : Tooltip(0){}
  32.  
  33.     // Override virtuals from TApplication
  34.     //
  35.     void    InitMainWindow();
  36.  
  37.     // Application's tooltip control
  38.     //
  39.     TTooltip* Tooltip;
  40. };
  41.  
  42. //
  43. // class TClientWindow
  44. // ~~~~~ ~~~~~~~~~~~~~
  45. class TClientWindow : public TWindow {
  46.   public:
  47.     TClientWindow(TWindow* parent= 0);
  48.  
  49.   protected:
  50.  
  51.     bool            PreProcessMsg(MSG& msg);
  52.     void            Paint(TDC& dc, bool erase, TRect& rect);
  53.     void            SetupWindow();
  54.  
  55.     // Command handlers
  56.     //
  57.     void            CmToolbarTip();
  58.     void            CeToolbarTip(TCommandEnabler&);
  59.     void            CmWindowTip();
  60.     void            CeWindowTip(TCommandEnabler&);
  61.  
  62.     // Notification handlers
  63.     //
  64.     void            GreenTipText(TTooltipText far& ttText);
  65.     void            YellowTipText(TTooltipText far& ttText);
  66.  
  67.     // Flags whether tooltip's active
  68.     //
  69.     bool            ToolbarTipActive;
  70.     bool            WindowTipActive;
  71.  
  72.   DECLARE_RESPONSE_TABLE(TClientWindow);
  73. };
  74.  
  75. DEFINE_RESPONSE_TABLE1(TClientWindow, TWindow)
  76.   EV_TTN_NEEDTEXT(ID_YELLOWTOOL, YellowTipText),
  77.   EV_TTN_NEEDTEXT(ID_GREENTOOL, GreenTipText),
  78.   EV_COMMAND(CM_TOOLBARTIP, CmToolbarTip),
  79.   EV_COMMAND_ENABLE(CM_TOOLBARTIP, CeToolbarTip),
  80.   EV_COMMAND(CM_WINDOWTIP, CmWindowTip),
  81.   EV_COMMAND_ENABLE(CM_WINDOWTIP, CeWindowTip),
  82. END_RESPONSE_TABLE;
  83.  
  84. //
  85. //
  86. //
  87. TClientWindow::TClientWindow(TWindow* parent) 
  88.               :TWindow(parent), ToolbarTipActive(true), WindowTipActive(true)
  89. {
  90. }
  91.  
  92. //
  93. //
  94. //
  95. void
  96. TClientWindow::SetupWindow()
  97. {
  98.   TWindow::SetupWindow();
  99.  
  100.   TSampleApp* app = TYPESAFE_DOWNCAST(GetApplication(), TSampleApp);
  101.   if (app) {
  102.     TTooltip* tooltip = app->Tooltip;
  103.     if (tooltip && tooltip->GetHandle()) {
  104.  
  105.       // Add tooltip for red rectangle - For this tip, we'll provide
  106.       // a string when adding the tool.
  107.       // NOTE: Since TToolInfo will cache the text, make sure that the
  108.       //       object's lifetime is valid for the lifetime of the tooltip
  109.       //
  110.       TToolInfo tiRed(*this, redRect, ID_REDTOOL, "Red rectangle");
  111.       tooltip->AddTool(tiRed);
  112.  
  113.       // Add tooltip for blue rectangle specifying string resource
  114.       //
  115.       TToolInfo tiBlue(*this, blueRect, ID_BLUETOOL,
  116.                       ID_BLUETOOL, *GetApplication());
  117.       tooltip->AddTool(tiBlue);
  118.  
  119.       // Add tooltip for yellow rectangle leaving out the text.
  120.       // Tooltip will send TTN_NEEDTEXT notification at runtime
  121.       //
  122.       TToolInfo tiYellow(*this, yellowRect, ID_YELLOWTOOL);
  123.       tooltip->AddTool(tiYellow);
  124.  
  125.       // Add tooltip for green rectangle leaving out the text.
  126.       // Tooltip will send TTN_NEEDTEXT notification at runtime
  127.       //
  128.       TToolInfo tiGreen(*this, greenRect, ID_GREENTOOL);
  129.       tooltip->AddTool(tiGreen);
  130.  
  131.       // Add tooltip for combobox in controlbar
  132.       //
  133.     }
  134.   }
  135. }
  136.  
  137. //
  138. //
  139. //
  140. bool
  141. TClientWindow::PreProcessMsg(MSG& msg)
  142. {
  143.   TSampleApp* app = TYPESAFE_DOWNCAST(GetApplication(), TSampleApp);
  144.   if (app) {
  145.     TTooltip* tooltip = app->Tooltip;
  146.     if (tooltip && tooltip->IsWindow()) 
  147.       tooltip->RelayEvent(msg);
  148.   }
  149.  
  150.   // Always let event go through!
  151.   //
  152.   return TWindow::PreProcessMsg(msg);
  153. }
  154.  
  155. //
  156. //
  157. //
  158. void
  159. TClientWindow::Paint(TDC& dc, bool /*erase*/, TRect& /*rect*/)
  160. {
  161.   dc.TextRect(blueRect, TColor(0, 0, 0xff));
  162.   dc.TextRect(redRect, TColor(0xff, 0, 0));
  163.   dc.TextRect(yellowRect, TColor(0xff, 0xff, 0));
  164.   dc.TextRect(greenRect, TColor(0, 0xff, 0));
  165. }
  166.  
  167. //
  168. //
  169. //
  170. void
  171. TClientWindow::GreenTipText(TTooltipText far& ttText)
  172. {
  173.   // Provide tiptext string using constant string
  174.   //
  175.   TTooltipText& foo = *(TTooltipText*)&ttText;
  176.   foo.CopyText("Green Rectangle");
  177. }
  178.  
  179. //
  180. //
  181. //
  182. void
  183. TClientWindow::YellowTipText(TTooltipText far& ttText)
  184. {
  185.   // Provide tiptext using a string resource
  186.   //
  187.   TTooltipText& foo = *(TTooltipText*)&ttText;
  188.   foo.SetText(ID_YELLOWTOOL, *GetApplication());
  189. }
  190.  
  191. void            
  192. TClientWindow::CmToolbarTip()
  193. {
  194.   ToolbarTipActive = !ToolbarTipActive;
  195.   TWindow* tb = GetApplication()->GetMainWindow()->ChildWithId(IDW_TOOLBAR);
  196.   if (tb) {
  197.     TGadgetWindow *gw = TYPESAFE_DOWNCAST(tb, TGadgetWindow);
  198.     if (gw)
  199.       gw->EnableTooltip(ToolbarTipActive);
  200.   }
  201. }
  202.  
  203. void            
  204. TClientWindow::CeToolbarTip(TCommandEnabler &ce)
  205. {
  206.   ce.SetCheck(ToolbarTipActive ? TCommandEnabler::Checked :
  207.                                  TCommandEnabler::Unchecked);
  208. }
  209.  
  210. void            
  211. TClientWindow::CmWindowTip()
  212. {
  213.   WindowTipActive = !WindowTipActive;
  214.   TSampleApp* app = TYPESAFE_DOWNCAST(GetApplication(), TSampleApp);
  215.   if (app) {
  216.     TTooltip* tooltip = app->Tooltip;
  217.     tooltip->Activate(WindowTipActive);
  218.   }
  219. }
  220.  
  221. void            
  222. TClientWindow::CeWindowTip(TCommandEnabler &ce)
  223. {
  224.   ce.SetCheck(WindowTipActive ? TCommandEnabler::Checked :
  225.                                 TCommandEnabler::Unchecked);
  226. }
  227.  
  228. //----------------------------------------------------------------------------
  229.  
  230. void
  231. TSampleApp::InitMainWindow()
  232. {
  233.   // Setup main window + client
  234.   //
  235.   SetMainWindow(new TDecoratedFrame(0, "Tooltip Example", 
  236.                 new TClientWindow()));
  237.  
  238.   // Create decoration objects
  239.   //
  240.   TStatusBar*  sbar = new TStatusBar(GetMainWindow());
  241.   TControlBar* cbar = new TControlBar(GetMainWindow());
  242.   cbar->Attr.Id = IDW_TOOLBAR;
  243.  
  244.   // Insert gadgets in control bar
  245.   //
  246.   cbar->Insert(*new TButtonGadget(CM_FILENEW, CM_FILENEW));
  247.   cbar->Insert(*new TButtonGadget(CM_FILEOPEN, CM_FILEOPEN));
  248.   cbar->Insert(*new TButtonGadget(CM_FILESAVE, CM_FILESAVE));
  249.   cbar->Insert(*new TButtonGadget(CM_FILEPRINT, CM_FILEPRINT));
  250.  
  251.   cbar->Insert(*new TSeparatorGadget);
  252.   cbar->Insert(*new TButtonGadget(CM_EDITUNDO, CM_EDITUNDO));
  253.   cbar->Insert(*new TButtonGadget(CM_EDITCUT, CM_EDITCUT));
  254.   cbar->Insert(*new TButtonGadget(CM_EDITCOPY, CM_EDITCOPY));
  255.   cbar->Insert(*new TButtonGadget(CM_EDITPASTE, CM_EDITPASTE));
  256.  
  257.   cbar->Insert(*new TSeparatorGadget);
  258.   TComboBox* cBox = new TComboBox(0, ID_COMBOBOX, 0, 0, 180, 150, 
  259.                                   CBS_DROPDOWNLIST, -1);
  260.   cbar->Insert(*new TControlGadget(*cBox));
  261.  
  262.   // Insert decorations in main window
  263.   //
  264.   TYPESAFE_DOWNCAST(GetMainWindow(), TDecoratedFrame)->Insert(
  265.                     *cbar, TDecoratedFrame::Top);
  266.   TYPESAFE_DOWNCAST(GetMainWindow(), TDecoratedFrame)->Insert(
  267.                     *sbar, TDecoratedFrame::Bottom);
  268.  
  269.   GetMainWindow()->AssignMenu(IDM_MAINMENU);
  270.  
  271.   // Associated tooltip object with client window of our SDI application
  272.   //
  273.   Tooltip = new TTooltip(GetMainWindow()->GetClientWindow());
  274. }
  275.  
  276. //
  277. //
  278. //
  279. int
  280. OwlMain(int /*argc*/, char* /*argv*/ [])
  281. {
  282.   return TSampleApp().Run();
  283. }
  284.